home *** CD-ROM | disk | FTP | other *** search
/ C/C++ Users Group Library 1996 July / C-C++ Users Group Library July 1996.iso / listings / v_13_08 / phillip2 / wtiff.c < prev    next >
Encoding:
C/C++ Source or Header  |  1993-06-07  |  20.1 KB  |  719 lines
  1.  
  2.        /**********************************************
  3.        *
  4.        *  file d:\cips\wtiff.c
  5.        *
  6.        *  Functions: This file contains
  7.        *      create_file_if_needed
  8.        *      create_allocate_tiff_file
  9.        *      write_array_into_tiff_image
  10.        *      write_line
  11.        *      insert_short_into_buffer
  12.        *      insert_long_into_buffer
  13.        *      round_off_image_size
  14.        *      does_not_exist
  15.        *
  16.        *  Purpose:
  17.        *     These functions create TIFF image files 
  18.        *     on disk and insert a ROWSxCOLS array
  19.        *     into a tiff image already stored on disk.
  20.        *
  21.        *  External Calls:
  22.        *     rtiff.c - seek_to_first_line
  23.        *               seek_to_end_of_line
  24.        *     tiff.c - read_tiff_header
  25.        *
  26.        *  Modifications:
  27.        *     29 January 1991 - created
  28.        *     28 March 1993 - replaced open, lseek
  29.        *         etc. with fopen, fseek, etc.
  30.        *     10 May 1993 - added a number of tags
  31.        *         to make the TIFF files I create
  32.        *         TIFF 6.0 Gray Scale image compliant.
  33.        *
  34.        *********************************************/
  35.  
  36. #include "cips.h"
  37.  
  38.  
  39.  
  40.  
  41.  
  42.        /**********************************************
  43.        *
  44.        *   create_file_if_needed(...
  45.        *
  46.        *   This function creates a file on disk
  47.        *   if it does not exist.  The out file is
  48.        *   patterned after the in file.
  49.        *
  50.        ***********************************************/
  51.  
  52. create_file_if_needed(in_name, out_name, out_image)
  53.    char in_name[], out_name[];
  54.    short out_image[ROWS][COLS];
  55. {
  56.    int    length, width;
  57.    struct tiff_header_struct image_header;
  58.  
  59.    if(does_not_exist(out_name)){
  60.       printf("\n\n output file does not exist %s",
  61.                out_name);
  62.       read_tiff_header(in_name, &image_header);
  63.       round_off_image_size(&image_header,
  64.                            &length, &width);
  65.       image_header.image_length = length*ROWS;
  66.       image_header.image_width  = width*COLS;
  67.       create_allocate_tiff_file(out_name, &image_header,
  68.                                 out_image);
  69.    }  /* ends if does_not_exist */
  70. }  /* ends create_file_if_needed */
  71.  
  72.  
  73.  
  74.  
  75.  
  76.    /**********************************************
  77.    *
  78.    *   create_alllocate_tiff_file(...
  79.    *
  80.    *   This function creates a file on disk that will be
  81.    *   large enough to hold a tiff image.  The input
  82.    *   tiff_header_struct describes the desired tiff file.
  83.    *   This function writes the tiff header and then
  84.    *   writes a blank image array out to disk the proper
  85.    *   number of times.  This has the effect of allocating
  86.    *   the correct number of bytes on the disk.
  87.    *
  88.    *   There will be 18 entries in the IFD.
  89.    *   The image data will begin at byte 296.
  90.    *   I will use LSB first data.
  91.    *   I will have one strip for the entire image.
  92.    *   Black is zero.
  93.    *   The component values for the image are CHUNKY
  94.    *      (Planer configuration = 1).
  95.    *
  96.    ***************************************************/
  97.  
  98.  
  99. create_allocate_tiff_file(file_name, 
  100.                           image_header, image)
  101.    char   file_name[];
  102.    short  image[ROWS][COLS];
  103.    struct tiff_header_struct *image_header;
  104. {
  105.    char  buffer[12], long_buffer[50];
  106.    FILE  *image_file;
  107.    int   bytes_written,
  108.          i,
  109.          j,
  110.          l,
  111.          w;
  112.  
  113.    long  k;
  114.  
  115.  
  116.  
  117.       /***************************************
  118.       *
  119.       *   Create the image file in binary mode
  120.       *   for both reading and writing.
  121.       *
  122.       ****************************************/
  123.  
  124.    image_file = fopen(file_name, "wb");
  125.  
  126.       /***************************************
  127.       *
  128.       *   Write out the first 8 bytes of the
  129.       *   header.  The meaning of the
  130.       *   bytes (HEX) is:
  131.       *      0-1 = 49 49 - LSB first
  132.       *      2-3 = 2A 00 - version #
  133.       *      4-7 = 08 00 00 00 - go to offset
  134.       *           8 for the first
  135.       *           Image File
  136.       *           Directory
  137.       *
  138.       ****************************************/
  139.  
  140.    buffer[0] = 0x49;
  141.    buffer[1] = 0x49;
  142.    buffer[2] = 0x2A;
  143.    buffer[3] = 0x00;
  144.    buffer[4] = 0x08;
  145.    buffer[5] = 0x00;
  146.    buffer[6] = 0x00;
  147.    buffer[7] = 0x00;
  148.  
  149.    bytes_written = fwrite(buffer, 1, 8, image_file);
  150.  
  151.    printf("\n wrote %d bytes", bytes_written);
  152.  
  153.       /***************************************
  154.       *
  155.       *   Write out the first 2 bytes of the
  156.       *   Image File Directory.  These tell
  157.       *   the number of entries in the IFD.
  158.       *
  159.       ****************************************/
  160.  
  161.    buffer[0] = 0x12;
  162.    buffer[1] = 0x00;
  163.    bytes_written = fwrite(buffer, 1, 2, image_file);
  164.  
  165.    printf("\n wrote %d bytes", bytes_written);
  166.  
  167.       /***************************************
  168.       *
  169.       *   Write out the entries into the
  170.       *   Image File Directory.
  171.       *
  172.       ****************************************/
  173.  
  174.  
  175.       /* New Subfile Type */
  176.    buffer[0]  = 0xFE;
  177.    buffer[1]  = 0x00;
  178.    buffer[2]  = 0x03;
  179.    buffer[3]  = 0x00;
  180.    buffer[4]  = 0x01;
  181.    buffer[5]  = 0x00;
  182.    buffer[6]  = 0x00;
  183.    buffer[7]  = 0x00;
  184.    buffer[8]  = 0x00;
  185.    buffer[9]  = 0x00;
  186.    buffer[10] = 0x00;
  187.    buffer[11] = 0x00;
  188.    bytes_written = fwrite(buffer, 1, 12, image_file);
  189.    printf("\n wrote %d bytes", bytes_written);
  190.  
  191.  
  192.       /* Subfile Type */
  193.    buffer[0]  = 0xFF;
  194.    buffer[1]  = 0x00;
  195.    buffer[2]  = 0x03;
  196.    buffer[3]  = 0x00;
  197.    buffer[4]  = 0x01;
  198.    buffer[5]  = 0x00;
  199.    buffer[6]  = 0x00;
  200.    buffer[7]  = 0x00;
  201.    buffer[8]  = 0x01;
  202.    buffer[9]  = 0x00;
  203.    buffer[10] = 0x00;
  204.    buffer[11] = 0x00;
  205.    bytes_written = fwrite(buffer, 1, 12, image_file);
  206.    printf("\n wrote %d bytes", bytes_written);
  207.  
  208.  
  209.       /* Image Width */
  210.    insert_short_into_buffer(buffer, 0, 256);
  211.    insert_short_into_buffer(buffer, 2, 3);
  212.    insert_short_into_buffer(buffer, 4, 1);
  213.    insert_short_into_buffer(buffer, 8, 
  214.                      image_header->image_width);
  215.    bytes_written = fwrite(buffer, 1, 12, image_file);
  216.    printf("\n wrote %d bytes", bytes_written);
  217.  
  218.  
  219.       /* Image Length */
  220.    insert_short_into_buffer(buffer, 0, 257);
  221.    insert_short_into_buffer(buffer, 2, 3);
  222.    insert_short_into_buffer(buffer, 4, 1);
  223.    insert_short_into_buffer(buffer, 8, 
  224.                      image_header->image_length);
  225.    bytes_written = fwrite(buffer, 1, 12, image_file);
  226.    printf("\n wrote %d bytes", bytes_written);
  227.  
  228.  
  229.       /* Bits Per Sample */
  230.    insert_short_into_buffer(buffer, 0, 258);
  231.    insert_short_into_buffer(buffer, 2, 3);
  232.    insert_short_into_buffer(buffer, 4, 1);
  233.    insert_short_into_buffer(buffer, 8, 
  234.                      image_header->bits_per_pixel);
  235.    bytes_written = fwrite(buffer, 1, 12, image_file);
  236.    printf("\n wrote %d bytes", bytes_written);
  237.  
  238.  
  239.       /* Compression - None */
  240.    insert_short_into_buffer(buffer, 0, 259);
  241.    insert_short_into_buffer(buffer, 2, 3);
  242.    insert_short_into_buffer(buffer, 4, 1);
  243.    insert_short_into_buffer(buffer, 8, 1);
  244.    bytes_written = fwrite(buffer, 1, 12, image_file);
  245.    printf("\n wrote %d bytes", bytes_written);
  246.  
  247.  
  248.       /* Photometric Interpretation */
  249.       /* set to 1 because BLACK is ZERO */
  250.    insert_short_into_buffer(buffer, 0, 262);
  251.    insert_short_into_buffer(buffer, 2, 3);
  252.    insert_short_into_buffer(buffer, 4, 1);
  253.    insert_short_into_buffer(buffer, 8, 1);
  254.    bytes_written = fwrite(buffer, 1, 12, image_file);
  255.    printf("\n wrote %d bytes", bytes_written);
  256.  
  257.  
  258.       /* Strip Offset */
  259.       /* start after software name at 296 */
  260.    insert_short_into_buffer(buffer, 0, 273);
  261.    insert_short_into_buffer(buffer, 2, 3);
  262.    insert_short_into_buffer(buffer, 4, 1);
  263.    insert_short_into_buffer(buffer, 8, 296);
  264.    bytes_written = fwrite(buffer, 1, 12, image_file);
  265.    printf("\n wrote %d bytes", bytes_written);
  266.  
  267.  
  268.       /* Samples per Pixel */
  269.    insert_short_into_buffer(buffer, 0, 277);
  270.    insert_short_into_buffer(buffer, 2, 3);
  271.    insert_short_into_buffer(buffer, 4, 1);
  272.    insert_short_into_buffer(buffer, 8, 1);
  273.    bytes_written = fwrite(buffer, 1, 12, image_file);
  274.    printf("\n wrote %d bytes", bytes_written);
  275.  
  276.  
  277.       /* clear buffer */
  278.    for(i=0; i<12; i++) buffer[i] = 0x00;
  279.  
  280.       /* Rows Per Strip 1 strip for the entire image */
  281.       /* use 2E32 - 1, which is max */
  282.    insert_short_into_buffer(buffer, 0, 278);
  283.    insert_short_into_buffer(buffer, 2, 4);
  284.    insert_short_into_buffer(buffer, 4, 1);
  285.    insert_long_into_buffer(buffer, 8, 4294967295);
  286.    bytes_written = fwrite(buffer, 1, 12, image_file);
  287.    printf("\n wrote %d bytes", bytes_written);
  288.  
  289.  
  290.       /* Strip Byte Counts */
  291.       /* this = image width times length */
  292.    insert_short_into_buffer(buffer, 0, 279);
  293.    insert_short_into_buffer(buffer, 2, 4);
  294.    insert_short_into_buffer(buffer, 4, 1);
  295.    insert_long_into_buffer(buffer, 8, 
  296.     (long)(image_header->image_length *
  297.            image_header->image_width));
  298.    bytes_written = fwrite(buffer, 1, 12, image_file);
  299.    printf("\n wrote %d bytes", bytes_written);
  300.  
  301.  
  302.       /* Min Sample Value */
  303.    insert_short_into_buffer(buffer, 0, 280);
  304.    insert_short_into_buffer(buffer, 2, 3);
  305.    insert_short_into_buffer(buffer, 4, 1);
  306.    insert_short_into_buffer(buffer, 8, 0);
  307.    bytes_written = fwrite(buffer, 1, 12, image_file);
  308.    printf("\n wrote %d bytes", bytes_written);
  309.  
  310.  
  311.       /* Max Sample Value */
  312.    insert_short_into_buffer(buffer, 0, 281);
  313.    insert_short_into_buffer(buffer, 2, 3);
  314.    insert_short_into_buffer(buffer, 4, 1);
  315.    if(image_header->bits_per_pixel == 8)
  316.       insert_short_into_buffer(buffer, 8, 255);
  317.    else
  318.       insert_short_into_buffer(buffer, 8, 15);
  319.    bytes_written = fwrite(buffer, 1, 12, image_file);
  320.    printf("\n wrote %d bytes", bytes_written);
  321.  
  322.  
  323.       /* X Resolution */
  324.       /* Store the 8 bytes for this value
  325.          starting at 230 */
  326.    insert_short_into_buffer(buffer, 0, 282);
  327.    insert_short_into_buffer(buffer, 2, 5);
  328.    insert_short_into_buffer(buffer, 4, 1);
  329.    insert_short_into_buffer(buffer, 8, 230);
  330.    bytes_written = fwrite(buffer, 1, 12, image_file);
  331.    printf("\n wrote %d bytes", bytes_written);
  332.  
  333.  
  334.       /* Y Resolution */
  335.       /* Store the 8 bytes for this value
  336.          starting at 238 */
  337.    insert_short_into_buffer(buffer, 0, 283);
  338.    insert_short_into_buffer(buffer, 2, 5);
  339.    insert_short_into_buffer(buffer, 4, 1);
  340.    insert_short_into_buffer(buffer, 8, 238);
  341.    bytes_written = fwrite(buffer, 1, 12, image_file);
  342.    printf("\n wrote %d bytes", bytes_written);
  343.  
  344.  
  345.  
  346.       /* clear buffer */
  347.    for(i=0; i<12; i++) buffer[i] = 0x00;
  348.  
  349.       /* Planer Configuration */
  350.       /* chunky */
  351.    insert_short_into_buffer(buffer, 0, 284);
  352.    insert_short_into_buffer(buffer, 2, 3);
  353.    insert_short_into_buffer(buffer, 4, 1);
  354.    insert_short_into_buffer(buffer, 8, 1);
  355.    bytes_written = fwrite(buffer, 1, 12, image_file);
  356.    printf("\n wrote %d bytes", bytes_written);
  357.  
  358.  
  359.       /* Resolution Unit */
  360.       /* inches */
  361.    insert_short_into_buffer(buffer, 0, 296);
  362.    insert_short_into_buffer(buffer, 2, 3);
  363.    insert_short_into_buffer(buffer, 4, 1);
  364.    insert_short_into_buffer(buffer, 8, 2);
  365.    bytes_written = fwrite(buffer, 1, 12, image_file);
  366.    printf("\n wrote %d bytes", bytes_written);
  367.  
  368.  
  369.       /* Software */
  370.       /* Put this a 246, 50 bytes */
  371.    insert_short_into_buffer(buffer, 0, 305);
  372.    insert_short_into_buffer(buffer, 2, 2);
  373.    insert_short_into_buffer(buffer, 4, 50);
  374.    insert_short_into_buffer(buffer, 8, 246);
  375.    bytes_written = fwrite(buffer, 1, 12, image_file);
  376.    printf("\n wrote %d bytes", bytes_written);
  377.  
  378.  
  379.       /* Offset to next IFD (0 means no more IFD's) */
  380.    for(i=0; i<12; i++) buffer[i] = 0x00;
  381.    bytes_written = fwrite(buffer, 1, 4, image_file);
  382.    printf("\n wrote %d bytes", bytes_written);
  383.  
  384.  
  385.       /* clear buffer */
  386.    for(i=0; i<12; i++) buffer[i] = 0x00;
  387.  
  388.       /* Now store the X Resolution
  389.          first long is numerator
  390.          second long is denominator */
  391.    insert_long_into_buffer(buffer, 0, 300L);
  392.    insert_long_into_buffer(buffer, 4, 1L);
  393.    bytes_written = fwrite(buffer, 1, 8, image_file);
  394.    printf("\n wrote %d bytes", bytes_written);
  395.  
  396.  
  397.       /* Now store the Y Resolution
  398.          first long is numerator
  399.          second long is denominator */
  400.    insert_long_into_buffer(buffer, 0, 300L);
  401.    insert_long_into_buffer(buffer, 4, 1L);
  402.    bytes_written = fwrite(buffer, 1, 8, image_file);
  403.    printf("\n wrote %d bytes", bytes_written);
  404.  
  405.  
  406.       /* Now store the software tag */
  407.    for(i=0; i<50; i++) long_buffer[i] = '\0';
  408.    strcpy(long_buffer,
  409.    "Dwayne Phillips C Image Processing System 1993");
  410.    long_buffer[46] = '\0';
  411.    long_buffer[47] = '\0';
  412.    long_buffer[48] = '\0';
  413.    long_buffer[49] = '\0';
  414.    bytes_written = fwrite(long_buffer, 1, 50, 
  415.                           image_file);
  416.    printf("\n wrote %d bytes", bytes_written);
  417.    printf("\n%s", long_buffer);
  418.  
  419.  
  420.  
  421.       /***************************************
  422.       *
  423.       *   Now write the image data.
  424.       *
  425.       ****************************************/
  426.  
  427.    printf("\n length is %ld", 
  428.           image_header->image_length);
  429.    printf("\n width is %ld", 
  430.           image_header->image_width);
  431.  
  432.    round_off_image_size(image_header, &l, &w);
  433.    k = l * w;
  434.  
  435.    if(image_header->bits_per_pixel == 8)
  436.       k = k/2;
  437.    else
  438.       k = k/4;
  439.    k++;
  440.  
  441.    for(i=0; i<ROWS; i++)
  442.       for(j=0; j<COLS; j++)
  443.         image[i][j] = 0;
  444.  
  445.    j = sizeof(short) * ROWS * COLS;
  446.  
  447.    for(i=0; i<k; i++){
  448.       bytes_written = fwrite(image, 1, j, image_file);
  449.       printf("\n wrote %d bytes", bytes_written);
  450.    }
  451.  
  452.  
  453.    fclose(image_file);
  454.  
  455. }  /* ends create_allocate_tiff_file */
  456.  
  457.  
  458.  
  459.  
  460.  
  461.        /*********************************************
  462.        *
  463.        * write_array_into_tiff_file(...
  464.        *
  465.        * This function takes an array of shorts and 
  466.        * writes them into an existing tiff image file.
  467.        *
  468.        **********************************************/
  469.  
  470. write_array_into_tiff_image(image_file_name, array,
  471.                             il, ie, ll, le)
  472.  
  473.         char    image_file_name[];
  474.         int     il, ie, ll, le;
  475.         short   array[ROWS][COLS];
  476. {
  477.  
  478.    char  buffer[COLS];
  479.    FILE  *image_file;
  480.    int   bytes_written,
  481.          closed,
  482.          i,
  483.           position,
  484.          written;
  485.  
  486.    float a;
  487.  
  488.    long  line_length,
  489.          offset;
  490.  
  491.    struct tiff_header_struct image_header;
  492.  
  493.  
  494.  
  495.    read_tiff_header(image_file_name, &image_header);
  496.  
  497.  
  498.       /***********************************************
  499.       *
  500.       *   Procedure:
  501.       *   Seek to the strip offset where the data begins.
  502.       *   Seek to the first line you want.
  503.       *   Loop over the lines you want to write.
  504.       *      Seek to the first element of the line.
  505.       *      Write the line.
  506.       *      Seek to the end of the data in that line.
  507.       *
  508.       ************************************************/
  509.  
  510.    image_file = fopen(image_file_name, "rb+");
  511.    position   = fseek(image_file,
  512.                       image_header.strip_offset, 
  513.                       SEEK_SET);
  514.    position   = seek_to_first_line(image_file,
  515.                                    &image_header, il);
  516.  
  517.    for(i=0; i<(ll-il); i++){
  518.       offset        = (ie-1)/
  519.                       (8/image_header.bits_per_pixel);
  520.       position      = fseek(image_file, offset, 
  521.                             SEEK_CUR);
  522.       bytes_written = write_line(image_file, array,
  523.                                  i, &image_header, 
  524.                                  ie, le);
  525.       position      = seek_to_end_of_line(image_file,
  526.                                           le, 
  527.                                           &image_header);
  528.       position      = fseek(image_file, 1, SEEK_CUR);
  529.    }  /* ends loop over i  */
  530.  
  531.    closed = fclose(image_file);
  532.  
  533. }  /*  ends write_array_into_tiff_image */
  534.  
  535.  
  536.  
  537.  
  538.        /*********************************************
  539.        *
  540.        *   write_line(...
  541.        *
  542.        *   This function takes an array of shorts, 
  543.        *   extracts the numbers and puts them into 
  544.        *   a buffer, then writes this buffer into a 
  545.        *   tiff file on disk. The process depends on 
  546.        *   the number of bits per pixel used in the 
  547.        *   file (4 or 8).
  548.        *
  549.        **********************************************/
  550.  
  551. write_line(image_file, array, line_number, 
  552.            image_header, ie, le)
  553.    FILE   *image_file;
  554.    int    ie, le, line_number;
  555.    short  array[ROWS][COLS];
  556.    struct tiff_header_struct *image_header;
  557. {
  558.    char     buffer[COLS], first, second;
  559.    float    a, b;
  560.    int      bytes_written, i;
  561.    unsigned int bytes_to_write;
  562.    union    short_char_union scu;
  563.  
  564.    for(i=0; i<COLS; i++)
  565.       buffer[i] = '\0';
  566.  
  567.    bytes_to_write = (le-ie)/
  568.                     (8/image_header->bits_per_pixel);
  569.  
  570.    for(i=0; i<bytes_to_write; i++){
  571.  
  572.         /**********************************************
  573.         *
  574.         *   Use unions defined in cips.h to stuff shorts
  575.         *   into bytess.
  576.         *
  577.         **********************************************/
  578.  
  579.       if(image_header->bits_per_pixel == 8){
  580.        scu.s_num = 0;
  581.        scu.s_num = array[line_number][i];
  582.        buffer[i] = scu.s_alpha[0];
  583.       }  /* ends if bits_per_pixel == 8 */
  584.  
  585.  
  586.       if(image_header->bits_per_pixel == 4){
  587.  
  588.        scu.s_num = 0;
  589.        scu.s_num = array[line_number][i*2];
  590.        first     = scu.s_alpha[0] << 4;
  591.  
  592.        scu.s_num = 0;
  593.        scu.s_num = array[line_number][i*2];
  594.        second    = scu.s_alpha[0] & 0X000F;
  595.  
  596.        buffer[i] = first | second;
  597.       }  /* ends if bits_per_pixel == 4 */
  598.  
  599.    }  /*  ends loop over i  */
  600.  
  601.  
  602.    bytes_written = fwrite(buffer, 1, bytes_to_write, 
  603.                           image_file);
  604.  
  605.    return(bytes_written);
  606.  
  607. }  /* ends write_line  */
  608.  
  609.  
  610.  
  611.  
  612.  
  613.  
  614.    /***************************************
  615.    *
  616.    *   insert_short_into_buffer(...
  617.    *
  618.    *   This inserts a two byte short into a
  619.    *   buffer of characters.  It does this
  620.    *   is LSB order.
  621.    *
  622.    ***************************************/
  623.  
  624.  
  625. insert_short_into_buffer(buffer, start, number)
  626.     char  buffer[];
  627.     int   start;
  628.     short number;
  629. {
  630.     union short_char_union lsu;
  631.  
  632.     lsu.s_num       = number;
  633.     buffer[start+0] = lsu.s_alpha[0];
  634.     buffer[start+1] = lsu.s_alpha[1];
  635.  
  636. }  /* ends insert_short_into_buffer */
  637.  
  638.  
  639.  
  640.  
  641.    /***************************************
  642.    *
  643.    *   insert_long_into_buffer(...
  644.    *
  645.    *   This inserts a four byte long into a
  646.    *   buffer of characters.  It does this
  647.    *   is LSB order.
  648.    *
  649.    ***************************************/
  650.  
  651.  
  652.  
  653. insert_long_into_buffer(buffer, start, number)
  654.     char buffer[];
  655.     int  start;
  656.     long number;
  657. {
  658.     union long_char_union lsu;
  659.  
  660.     lsu.l_num       = number;
  661.     buffer[start+0] = lsu.l_alpha[0];
  662.     buffer[start+1] = lsu.l_alpha[1];
  663.     buffer[start+2] = lsu.l_alpha[2];
  664.     buffer[start+3] = lsu.l_alpha[3];
  665.  
  666. }  /* ends insert_short_into_buffer */
  667.  
  668.  
  669.  
  670.  
  671.    /***************************************
  672.    *
  673.    *   round_off_image_size(...
  674.    *
  675.    *   This takes the image header and rounds
  676.    *   it off to a multiple of ROWS and COLS.
  677.    *   e.g. if width=123 it returns 1.
  678.    *
  679.    ***************************************/
  680.  
  681.  
  682. round_off_image_size(image_header, length, width)
  683.     int    *length, *width;
  684.     struct tiff_header_struct *image_header;
  685. {
  686.    *length = (ROWS-10 + image_header->image_length)/ROWS;
  687.    *width  = (COLS-10 + image_header->image_width)/COLS;
  688. } /* ends round_off_image_size */
  689.  
  690.  
  691.  
  692.  
  693.  
  694.    /***********************************************
  695.     *
  696.     *    does_not_exist(...
  697.     *
  698.     *    This function checks the disk to see if
  699.     *    a file exists.  If the file is there this
  700.     *    function returns a 0, if it does not exist
  701.     *    this function returns a 1.
  702.     *
  703.     ***********************************************/
  704.  
  705. does_not_exist(file_name)
  706.     char file_name[];
  707. {
  708.    FILE *image_file;
  709.    int  result;
  710.  
  711.    result = 1;
  712.    image_file = fopen(file_name, "rb");
  713.    if(image_file != NULL){
  714.       result = 0;
  715.       fclose(image_file);
  716.    }
  717.    return(result);
  718. }  /* ends does_not_exist */
  719.